



package com.loong.android.views;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.text.Html;
import android.text.InputFilter;
import android.text.Spanned;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.ViewParent;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.loong.android.R;
import com.loong.android.views.data.BgLinearGradient;
import com.loong.android.views.data.BgRadialGradient;
import com.loong.android.views.utils.GravityUtils;
import com.loong.android.views.utils.BitmapUtils;
import com.loong.android.views.utils.Ellipsize;
import com.loong.android.views.utils.TextStyle;
import com.loong.android.utils.CharSequenceUtils;
import com.loong.android.views.utils.Unit;
import com.loong.android.views.utils.ViewDrawable;
import com.loong.android.views.utils.ViewImpl;
import com.loong.android.views.utils.ViewTemplate;
import com.loong.android.views.utils.ViewUtils;

public class LonButton extends androidx.appcompat.widget.AppCompatTextView implements ViewTemplate {
    //region vars
    private final ViewImpl viewImpl = new ViewImpl(this);

    private Integer mBackgroundColorPressed = null;
    private Bitmap mBackgroundBitmapPressed = null;

    private Integer mBorderWidthPressed = null;
    private Integer mBorderTypePressed = null;
    private Integer mBorderColorPressed = null;
    //圆角
    private float[] mCornerRadiiPressed = null;

    private Float mShadowRadiusPressed = null;
    private Float mShadowDxPressed = null;
    private Float mShadowDyPressed = null;
    private Integer mShadowColorPressed = null;

    private String mHtml = null;
    private String mText = null;
    private int mTextSize = 0;
    private int mTextColor = 0;
    private int mTextStyle = 0;
    private boolean mUnderLine = false;
    private boolean mDeleteLine = false;

    private String mHtmlPressed = null;
    private String mTextPressed = null;
    private Boolean mUnderLinePressed = null;
    private Boolean mDeleteLinePressed = null;
    private Integer mTextStylePressed = null;
    private Integer mTextSizePressed = null;
    private Integer mTextColorPressed = null;

    private float mLinearGradientX0Pressed = 0;
    private float mLinearGradientY0Pressed = 0;
    private float mLinearGradientX1Pressed = 1;
    private float mLinearGradientY1Pressed = 1;
    private int mLinearGradientModePressed = 0;
    private int[] mLinearGradientColorsPressed = null;
    private float[] mLinearGradientPositionsPressed = null;
    private Integer mLinearGradientColorStartPressed = Color.TRANSPARENT;
    private Integer mLinearGradientColorEndPressed = Color.TRANSPARENT;

    private float mRadialGradientCenterXPressed = 0.5f;
    private float mRadialGradientCenterYPressed = 0.5f;
    private float mRadialGradientRadiusPressed = -2;
    private int mRadialGradientModePressed = 0;
    private int[] mRadialGradientColorsPressed = null;
    private float[] mRadialGradientPositionsPressed = null;
    private Integer mRadialGradientColorCenterPressed = Color.TRANSPARENT;
    private Integer mRadialGradientColorEdgePressed = Color.TRANSPARENT;

    private BgLinearGradient mBgLinearGradientPressed = null;
    private BgRadialGradient mBgRadialGradientPressed = null;
    private boolean mPressStatus = false;

    //endregion

    public LonButton(Context context) {
        super(context);
        initAttrs(context, null);
    }

    public LonButton(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        initAttrs(context, attrs);
    }

    public LonButton(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initAttrs(context, attrs);
    }

    private void initAttrs(Context context, AttributeSet attrs) {

        if (context == null) return;

        viewImpl.setBackgroundColor(Color.parseColor("#FFD6D7D7"));
        int defCorner = ViewUtils.dp2px(context, 4);
        float[] defCornerRadii = new float[]{defCorner, defCorner, defCorner, defCorner,
                defCorner, defCorner, defCorner, defCorner};
        viewImpl.setCornerRadii(defCornerRadii);
        viewImpl.initView(context, attrs);

        mText = "按钮";
        mTextSize = ViewUtils.sp2px(context, 14);
        mTextColor = Color.rgb(30, 31, 32);
        mTextStyle = TextStyle.NORMAL;

        mBackgroundColorPressed = Color.parseColor("#FFC2C3C3");

        int btnGravity = GravityUtils.TOP_LEFT;

        if (attrs != null) {
            @SuppressLint("CustomViewStyleable")
            TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.Button);

            mText = ta.getString(R.styleable.Button_android_text);
            mTextSize = ta.getDimensionPixelSize(R.styleable.Button_android_textSize, mTextSize);
            mTextColor = ta.getColor(R.styleable.Button_android_textColor, mTextColor);
            mUnderLine = ta.getBoolean(R.styleable.Button_underline, mUnderLine);
            mDeleteLine = ta.getBoolean(R.styleable.Button_deleteLine, mDeleteLine);

            btnGravity = ta.getInt(R.styleable.Button_gravity, btnGravity);
            mTextStyle = ta.getInt(R.styleable.Button_fontType, mTextStyle);

            if (ta.hasValue(R.styleable.Button_html)) {
                mHtml = ta.getString(R.styleable.Button_html);
            }

            //按下背景颜色
            if (ta.hasValue(R.styleable.Button_backgroundColorPressed)) {
                mBackgroundColorPressed = ta.getColor(R.styleable.Button_backgroundColorPressed, Color.TRANSPARENT);
            }
            //按下背景图片
            int backgroundResId = ta.getResourceId(R.styleable.Button_backgroundPressed, -1);
            if (backgroundResId != -1) {
                mBackgroundBitmapPressed = BitmapUtils.fromResource(context, backgroundResId);
            }
            //按下边框宽度
            mBorderWidthPressed = ta.getDimensionPixelSize(R.styleable.Button_borderWidthPressed, -1);
            //按下边框颜色
            if (ta.hasValue(R.styleable.Button_borderColorPressed)) {
                mBorderColorPressed = ta.getColor(R.styleable.Button_borderColorPressed, Color.TRANSPARENT);
            }
            //按下边框类型
            mBorderTypePressed = ta.getInt(R.styleable.Button_borderTypePressed, -1);
            //按下阴影半径
            mShadowRadiusPressed = ta.getDimension(R.styleable.Button_shadowRadiusPressed, -1);
            //按下阴影水平偏移
            if (ta.hasValue(R.styleable.Button_shadowDxPressed)) {
                mShadowDxPressed = ta.getDimension(R.styleable.Button_shadowDxPressed, 0);
            }
            //按下阴影垂直偏移
            if (ta.hasValue(R.styleable.Button_shadowDyPressed)) {
                mShadowDyPressed = ta.getDimension(R.styleable.Button_shadowDyPressed, 0);
            }
            //按下阴影颜色
            if (ta.hasValue(R.styleable.Button_shadowColorPressed)) {
                mShadowColorPressed = ta.getColor(R.styleable.Button_shadowColorPressed, Color.TRANSPARENT);
            }
            boolean hasRadii = false;
            int cornerTopLeft = 0, cornerTopRight = 0, cornerBottomLeft = 0, cornerBottomRight = 0;
            if (ta.hasValue(R.styleable.Button_cornerPressed)) {
                hasRadii = true;
                cornerTopLeft = ta.getDimensionPixelSize(R.styleable.Button_cornerPressed, -1);
                cornerTopRight = cornerTopLeft;
                cornerBottomRight = cornerTopLeft;
                cornerBottomLeft = cornerTopLeft;
            }
            if (ta.hasValue(R.styleable.Button_cornerTopLeftPressed)) {
                hasRadii = true;
                cornerTopLeft = ta.getDimensionPixelSize(R.styleable.Button_cornerTopLeftPressed, -1);
            }
            if (ta.hasValue(R.styleable.Button_cornerTopRightPressed)) {
                hasRadii = true;
                cornerTopRight = ta.getDimensionPixelSize(R.styleable.Button_cornerTopRightPressed, -1);
            }
            if (ta.hasValue(R.styleable.Button_cornerBottomRightPressed)) {
                hasRadii = true;
                cornerBottomRight = ta.getDimensionPixelSize(R.styleable.Button_cornerBottomRightPressed, -1);
            }
            if (ta.hasValue(R.styleable.Button_cornerBottomLeftPressed)) {
                hasRadii = true;
                cornerBottomLeft = ta.getDimensionPixelSize(R.styleable.Button_cornerBottomLeftPressed, -1);
            }
            if (hasRadii) {
                mCornerRadiiPressed = new float[]{
                        cornerTopLeft, cornerTopLeft, cornerTopRight, cornerTopRight,
                        cornerBottomRight, cornerBottomRight, cornerBottomLeft, cornerBottomLeft
                };
            }

            mTextPressed = ta.getString(R.styleable.Button_textPressed);
            mHtmlPressed = ta.getString(R.styleable.Button_htmlPressed);
            mTextSizePressed = ta.getDimensionPixelSize(R.styleable.Button_textSizePressed, -1);

            //按下文本颜色
            if (ta.hasValue(R.styleable.Button_textColorPressed)) {
                mTextColorPressed = ta.getColor(R.styleable.Button_textColorPressed, Color.TRANSPARENT);
            }
            //按下文本下划线
            if (ta.hasValue(R.styleable.Button_underlinePressed)) {
                mUnderLinePressed = ta.getBoolean(R.styleable.Button_underlinePressed, false);
            }
            //按下文本删除线
            if (ta.hasValue(R.styleable.Button_deleteLinePressed)) {
                mDeleteLinePressed = ta.getBoolean(R.styleable.Button_deleteLinePressed, false);
            }
            //按下文本样式
            mTextStylePressed = ta.getInt(R.styleable.Button_fontTypePressed, -1);

            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientX0Pressed)) {
                mLinearGradientX0Pressed = ta.getFloat(R.styleable.Button_backgroundLinearGradientX0Pressed, mLinearGradientX0Pressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientY0Pressed)) {
                mLinearGradientY0Pressed = ta.getFloat(R.styleable.Button_backgroundLinearGradientY0Pressed, mLinearGradientY0Pressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientX1Pressed)) {
                mLinearGradientX1Pressed = ta.getFloat(R.styleable.Button_backgroundLinearGradientX1Pressed, mLinearGradientX1Pressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientY1Pressed)) {
                mLinearGradientY1Pressed = ta.getFloat(R.styleable.Button_backgroundLinearGradientY1Pressed, mLinearGradientY1Pressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientColorStartPressed)) {
                mLinearGradientColorStartPressed = ta.getColor(R.styleable.Button_backgroundLinearGradientColorStartPressed, 0);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientColorEndPressed)) {
                mLinearGradientColorEndPressed = ta.getColor(R.styleable.Button_backgroundLinearGradientColorEndPressed, 0);
            }
            if (ta.hasValue(R.styleable.Button_backgroundLinearGradientModePressed)) {
                mLinearGradientModePressed = ta.getInt(R.styleable.Button_backgroundLinearGradientModePressed, 0);
            }

            resetBgLinearGradientPressed();

            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientCenterXPressed)) {
                mRadialGradientCenterXPressed = ta.getFloat(R.styleable.Button_backgroundRadialGradientCenterXPressed, mRadialGradientCenterXPressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientCenterYPressed)) {
                mRadialGradientCenterYPressed = ta.getFloat(R.styleable.Button_backgroundRadialGradientCenterYPressed, mRadialGradientCenterYPressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientRadiusPressed)) {
                mRadialGradientRadiusPressed = ta.getFloat(R.styleable.Button_backgroundRadialGradientRadiusPressed, mRadialGradientRadiusPressed);
            }
            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientColorCenterPressed)) {
                mRadialGradientColorCenterPressed = ta.getColor(R.styleable.Button_backgroundRadialGradientColorCenterPressed, 0);
            }
            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientColorEdgePressed)) {
                mRadialGradientColorEdgePressed = ta.getColor(R.styleable.Button_backgroundRadialGradientColorEdgePressed, 0);
            }
            if (ta.hasValue(R.styleable.Button_backgroundRadialGradientModePressed)) {
                mRadialGradientModePressed = ta.getInt(R.styleable.Button_backgroundRadialGradientModePressed, 0);
            }

            resetBgRadialGradientPressed();

            ta.recycle();
        }

        callButtonOnTouch();
        callButtonOnClick();
        callButtonOnLongClick();

        textGravity(GravityUtils.getGravity(btnGravity));
        if (mHtml != null) {
            loadHtml(mHtml);
        } else if (mText != null) {
            text(mText);
        }
        setTextStyle(mTextStyle);
        setTextColor(mTextColor);
        setTextSize(Unit.PX, mTextSize);
        setTitleStyle();

        //设置默认的padding
        boolean hasPaddingAttr = viewImpl.getAttrValuePadding() != null;
        boolean hasPaddingLeftAttr = viewImpl.getAttrValuePaddingLeft() != null;
        boolean hasPaddingRightAttr = viewImpl.getAttrValuePaddingRight() != null;
        boolean hasPaddingTopAttr = viewImpl.getAttrValuePaddingTop() != null;
        boolean hasPaddingBottomAttr = viewImpl.getAttrValuePaddingBottom() != null;

        if (!hasPaddingAttr && (!hasPaddingLeftAttr || !hasPaddingRightAttr || !hasPaddingTopAttr || !hasPaddingBottomAttr)) {
            int defPaddingX = ViewUtils.dp2px(context, 15);
            int defPaddingY = ViewUtils.dp2px(context, 10);
            int pLeft = getPaddingLeft(), pTop = getPaddingTop(), pRight = getPaddingRight(), pBottom = getPaddingBottom();
            //若未设置paddingLeft
            if (!hasPaddingLeftAttr) pLeft = defPaddingX;
            //若未设置paddingRight
            if (!hasPaddingRightAttr) pRight = defPaddingX;
            //若未设置paddingTop
            if (!hasPaddingTopAttr) pTop = defPaddingY;
            //若未设置paddingBottom
            if (!hasPaddingBottomAttr) pBottom = defPaddingY;

            setPadding(pLeft, pTop, pRight, pBottom);
        }

        viewImpl.drawBackgroundDrawable();
    }

    private void resetBgLinearGradientPressed() {
        mBgLinearGradientPressed = null;
        if(mLinearGradientColorsPressed != null) {
            mBgLinearGradientPressed = new BgLinearGradient(mLinearGradientX0Pressed, mLinearGradientY0Pressed,
                    mLinearGradientX1Pressed, mLinearGradientY1Pressed, mLinearGradientColorsPressed, mLinearGradientPositionsPressed, mLinearGradientModePressed);
        } else if (mLinearGradientColorStartPressed != null || mLinearGradientColorEndPressed != null) {
            if (mLinearGradientColorStartPressed == null)
                mLinearGradientColorStartPressed = Color.TRANSPARENT;
            if (mLinearGradientColorEndPressed == null)
                mLinearGradientColorEndPressed = Color.TRANSPARENT;
            mBgLinearGradientPressed = new BgLinearGradient(mLinearGradientX0Pressed, mLinearGradientY0Pressed,
                    mLinearGradientX1Pressed, mLinearGradientY1Pressed,
                    mLinearGradientColorStartPressed, mLinearGradientColorEndPressed, mLinearGradientModePressed);
        }
    }

    private void resetBgRadialGradientPressed() {
        if(mRadialGradientColorsPressed != null) {
            mBgRadialGradientPressed = new BgRadialGradient(mRadialGradientCenterXPressed, mRadialGradientCenterYPressed,
                    mRadialGradientRadiusPressed, mRadialGradientColorsPressed, mRadialGradientPositionsPressed, mRadialGradientModePressed);
        } else if (mRadialGradientColorCenterPressed != null || mRadialGradientColorEdgePressed != null) {
            if (mRadialGradientColorCenterPressed == null)
                mRadialGradientColorCenterPressed = Color.TRANSPARENT;
            if (mRadialGradientColorEdgePressed == null)
                mRadialGradientColorEdgePressed = Color.TRANSPARENT;
            mBgRadialGradientPressed = new BgRadialGradient(mRadialGradientCenterXPressed, mRadialGradientCenterYPressed,
                    mRadialGradientRadiusPressed,
                    mRadialGradientColorCenterPressed, mRadialGradientColorEdgePressed, mRadialGradientModePressed);
        }
    }

    public void drawBackgroundDrawable(boolean isPressed) {

        int bgColor = viewImpl.getBackgroundColor();
        int bWidth = viewImpl.getBorderWidth();
        int bColor = viewImpl.getBorderColor();
        int bType = viewImpl.getBorderType();
        Bitmap bgBitmap = viewImpl.getBackgroundBitmap();
        float sRadius = viewImpl.getShadowRadius();
        int sColor = viewImpl.getShadowColor();
        float sDx = viewImpl.getShadowDx();
        float sDy = viewImpl.getShadowDy();
        float[] cRii = viewImpl.getCornerRadii();

        BgLinearGradient bgLinearGradient = viewImpl.getBgLinearGradient();
        BgRadialGradient bgRadialGradient = viewImpl.getBgRadialGradient();

        if (isPressed) {
            if (mHtmlPressed != null) {
                if (!mHtmlPressed.equals(mHtml)) loadHtml(mHtmlPressed);
            } else if (mTextPressed != null) {
                if (!mTextPressed.equals(mText)) setText(mTextPressed);
            }
            if (mTextStylePressed != null && mTextStylePressed != -1 && mTextStylePressed != mTextStyle) {
                setTextStyle(mTextStylePressed);
            }
            if (mTextColorPressed != null && mTextColorPressed != mTextColor) {
                setTextColor(mTextColorPressed);
            }
            if (mTextSizePressed != null && mTextSizePressed != -1 && mTextSizePressed != mTextSize) {
                setTextSize(Unit.PX, mTextSizePressed);
            }
            if (mUnderLinePressed != null || mDeleteLinePressed != null) {
                boolean underLine = mUnderLinePressed != null ? mUnderLinePressed : false;
                boolean deleteLine = mDeleteLinePressed != null ? mDeleteLinePressed : false;
                if (underLine != mUnderLine || deleteLine != mDeleteLine) {
                    setTitleStyle(underLine, deleteLine);
                }
            }
            if (mBackgroundColorPressed != null) bgColor = mBackgroundColorPressed;
            if (mBorderWidthPressed != null && mBorderWidthPressed != -1)
                bWidth = mBorderWidthPressed;
            if (mBorderColorPressed != null) bColor = mBorderColorPressed;
            if (mBorderTypePressed != null && mBorderTypePressed != -1) bType = mBorderTypePressed;
            if (mBackgroundBitmapPressed != null) bgBitmap = mBackgroundBitmapPressed;
            if (mShadowRadiusPressed != null && mShadowRadiusPressed != -1)
                sRadius = mShadowRadiusPressed;
            if (mShadowDxPressed != null) sDx = mShadowDxPressed;
            if (mShadowDyPressed != null) sDy = mShadowDyPressed;
            if (mShadowColorPressed != null) sColor = mShadowColorPressed;
            if (mCornerRadiiPressed != null) cRii = mCornerRadiiPressed;

            bgLinearGradient = mBgLinearGradientPressed;
            bgRadialGradient = mBgRadialGradientPressed;

        } else {
            if ((mHtmlPressed != null && !mHtmlPressed.equals(mHtml)) || (mTextPressed != null && !mTextPressed.equals(mText))) {
                if (mHtml != null) {
                    loadHtml(mHtml);
                } else {
                    setText(mText == null ? "" : mText);
                }
            }
            if (mTextStylePressed != null && mTextStylePressed != -1 && mTextStylePressed != mTextStyle) {
                setTextStyle(mTextStyle);
            }
            if (mTextColorPressed != null && mTextColorPressed != mTextColor) {
                setTextColor(mTextColor);
            }
            if (mTextSizePressed != null && mTextSizePressed != -1 && mTextSizePressed != mTextSize) {
                setTextSize(Unit.PX, mTextSize);
            }
            if (mUnderLinePressed != null || mDeleteLinePressed != null) {
                boolean underLine = mUnderLinePressed != null ? mUnderLinePressed : false;
                boolean deleteLine = mDeleteLinePressed != null ? mDeleteLinePressed : false;
                if (underLine != mUnderLine || deleteLine != mDeleteLine) {
                    setTitleStyle();
                }
            }
        }

        //如果设置了水波纹特效，圆角、边框、阴影、背景颜色等都失效
        if (viewImpl.getRippleEffectStatus()) return;

        ViewDrawable drawable = new ViewDrawable(this);
        drawable.setBackgroundColor(bgColor);
        drawable.setLinearGradient(bgLinearGradient);
        drawable.setRadialGradient(bgRadialGradient);
        drawable.setBorderWidth(bWidth);
        drawable.setBorderColor(bColor);
        drawable.setBorderType(bType);
        drawable.setBackground(bgBitmap);
        drawable.setShadow(sRadius, sDx, sDy, sColor);
        if (cRii != null) {
            drawable.setRadius(cRii[0], cRii[2], cRii[4], cRii[6]);
        }
        setBackground(drawable);


    }

    private void setTitleStyle(boolean underLine, boolean deleteLine) {
        int style = Paint.ANTI_ALIAS_FLAG;
        if (underLine) style = style | Paint.UNDERLINE_TEXT_FLAG;
        if (deleteLine) style = style | Paint.STRIKE_THRU_TEXT_FLAG;
        getPaint().setFlags(style);
    }

    private void setTitleStyle() {
        setTitleStyle(mUnderLine, mDeleteLine);
    }

    private void recycleBackgroundBitmapPressed() {
        if (mBackgroundBitmapPressed == null || mBackgroundBitmapPressed.isRecycled()) return;
        mBackgroundBitmapPressed.recycle();
        mBackgroundBitmapPressed = null;
    }

    //region 自定义方法

    /**
     * 设置最大宽度
     *
     * @param w 宽度
     */
    public void maxWidth(int w) {
        setMaxWidth(w);
    }

    /**
     * 取最大宽度
     */
    public int maxWidth() {
        return getMaxWidth();
    }

    /**
     * 设置最大高度
     *
     * @param h 高度
     */
    public void maxHeight(int h) {
        setMaxHeight(h);
    }

    /**
     * 取最大高度
     */
    public int maxHeight() {
        return getMaxHeight();
    }

    /**
     * 置按下背景图片
     *
     * @param resId 图片资源id
     */
    public void backgroundPressed(int resId) {
        backgroundPressed(resId, true);
    }

    /**
     * 置按下背景图片
     *
     * @param resId   图片资源id
     * @param refresh 是否立即刷新
     */
    public void backgroundPressed(int resId, boolean refresh) {
        recycleBackgroundBitmapPressed();
        mBackgroundBitmapPressed = BitmapUtils.fromResource(getContext(), resId);
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下背景图片
     *
     * @param bitmap 图片位图数据
     */
    public void backgroundPressed(Bitmap bitmap) {
        backgroundPressed(bitmap, true);
    }

    /**
     * 置按下背景图片
     *
     * @param bitmap  图片位图数据
     * @param refresh 是否立即刷新
     */
    public void backgroundPressed(Bitmap bitmap, boolean refresh) {
        if (mBackgroundBitmapPressed != null && bitmap != null && !mBackgroundBitmapPressed.equals(bitmap)) {
            recycleBackgroundBitmapPressed();
        }
        mBackgroundBitmapPressed = bitmap;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下背景图片，注意需要先申请读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param filePath 图片文件地址
     */
    public void backgroundPressed(String filePath) {
        backgroundPressed(filePath, true);
    }

    /**
     * 置按下背景图片，注意需要先申请读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param filePath 图片文件地址
     * @param refresh  是否立即刷新，默认为true
     */
    public void backgroundPressed(String filePath, boolean refresh) {
        recycleBackgroundBitmapPressed();
        mBackgroundBitmapPressed = BitmapUtils.fromFile(filePath);
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下背景图片
     *
     * @param bytes 字节数组
     */
    public void backgroundPressed(byte[] bytes) {
        backgroundPressed(bytes, true);
    }

    /**
     * 置按下背景图片
     *
     * @param bytes   字节数组
     * @param refresh 是否立即刷新，默认为true
     */
    public void backgroundPressed(byte[] bytes, boolean refresh) {
        recycleBackgroundBitmapPressed();
        mBackgroundBitmapPressed = BitmapUtils.fromBytes(bytes);
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的背景图片的位图数据
     */
    public Bitmap backgroundPressed() {
        return mBackgroundBitmapPressed;
    }

    /**
     * 置按下的背景颜色
     *
     * @param color 颜色值
     */
    public void backgroundColorPressed(int color) {
        backgroundColorPressed(color, true);
    }

    /**
     * 置按下的背景颜色
     *
     * @param color   颜色值
     * @param refresh 是否立即刷新，默认为true
     */
    public void backgroundColorPressed(int color, boolean refresh) {
        mBackgroundColorPressed = color;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的背景颜色
     */
    public int backgroundColorPressed() {
        return mBackgroundColorPressed;
    }

    /**
     * 设置按下的线性渐变背景
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param colors 颜色数组，不同位置的颜色值
     * @param positions 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundLinearGradientPressed(float x0, float y0, float x1, float y1, int[] colors, float[] positions, int mode) {
        setBackgroundLinearGradientPressed(x0, y0, x1, y1, colors, positions, mode, true);
    }

    /**
     * 设置按下的线性渐变背景
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param colors 颜色数组，不同位置的颜色值
     * @param positions 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     * @param refresh 是否立即刷新，默认为true
     */
    public void setBackgroundLinearGradientPressed(float x0, float y0, float x1, float y1, int[] colors, float[] positions, int mode, boolean refresh) {
        mLinearGradientX0Pressed = x0;
        mLinearGradientY0Pressed = y0;
        mLinearGradientX1Pressed = x1;
        mLinearGradientY1Pressed = y1;
        mLinearGradientColorsPressed = colors;
        mLinearGradientPositionsPressed = positions;
        mLinearGradientModePressed = mode;
        resetBgLinearGradientPressed();
        if(refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 设置按下的线性渐变背景
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param color1 开始的颜色值
     * @param color2 结束的颜色值
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundLinearGradientPressed(float x0, float y0, float x1, float y1, int color1, int color2, int mode) {
        setBackgroundLinearGradientPressed(x0, y0, x1, y1, color1, color2, mode, true);
    }

    /**
     * 设置按下的线性渐变背景
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param color1 开始的颜色值
     * @param color2 结束的颜色值
     * @param mode 平铺方式，参考"TileMode"类的常量
     * @param refresh 是否立即刷新，默认为true
     */
    public void setBackgroundLinearGradientPressed(float x0, float y0, float x1, float y1, int color1, int color2, int mode, boolean refresh) {
        mLinearGradientX0Pressed = x0;
        mLinearGradientY0Pressed = y0;
        mLinearGradientX1Pressed = x1;
        mLinearGradientY1Pressed = y1;
        mLinearGradientColorStartPressed = color1;
        mLinearGradientColorEndPressed = color2;
        mLinearGradientModePressed = mode;
        resetBgLinearGradientPressed();
        if(refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 设置按下的环形渐变背景
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param colors 颜色数组，不同位置的颜色值
     * @param stops 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundRadialGradientPressed(float centerX, float centerY, float radius, int[] colors, float[] stops, int mode) {
        setBackgroundRadialGradientPressed(centerX, centerY, radius, colors, stops, mode, true);
    }

    /**
     * 设置按下的环形渐变背景
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param colors 颜色数组，不同位置的颜色值
     * @param stops 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     * @param refresh 是否立即刷新，默认为true
     */
    public void setBackgroundRadialGradientPressed(float centerX, float centerY, float radius, int[] colors, float[] stops, int mode, boolean refresh) {
        mRadialGradientCenterXPressed = centerX;
        mRadialGradientCenterYPressed = centerY;
        mRadialGradientRadiusPressed = radius;
        mRadialGradientColorsPressed = colors;
        mRadialGradientPositionsPressed = stops;
        mRadialGradientModePressed = mode;
        resetBgRadialGradientPressed();
        if(refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 设置按下的环形渐变背景
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param centerColor 中心点颜色
     * @param edgeColor 边缘颜色
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundRadialGradientPressed(float centerX, float centerY, float radius, int centerColor, int edgeColor, int mode) {
        setBackgroundRadialGradientPressed(centerX, centerY, radius, centerColor, edgeColor, mode, true);
    }

    /**
     * 设置按下的环形渐变背景
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param centerColor 中心点颜色
     * @param edgeColor 边缘颜色
     * @param mode 平铺方式，参考"TileMode"类的常量
     * @param refresh 是否立即刷新，默认为true
     */
    public void setBackgroundRadialGradientPressed(float centerX, float centerY, float radius, int centerColor, int edgeColor, int mode, boolean refresh) {
        mRadialGradientCenterXPressed = centerX;
        mRadialGradientCenterYPressed = centerY;
        mRadialGradientRadiusPressed = radius;
        mRadialGradientColorCenterPressed = centerColor;
        mRadialGradientColorEdgePressed = edgeColor;
        mRadialGradientModePressed = mode;
        resetBgRadialGradientPressed();
        if(refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下边框宽度
     *
     * @param w 宽度值
     */
    public void borderWidthPressed(int w) {
        borderWidthPressed(w, true);
    }

    /**
     * 置按下边框宽度
     *
     * @param w       宽度值
     * @param refresh 是否立即刷新，默认为true
     */
    public void borderWidthPressed(int w, boolean refresh) {
        mBorderWidthPressed = w;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的边框宽度
     */
    public int borderWidthPressed() {
        return mBorderWidthPressed;
    }

    /**
     * 置按下边框颜色
     *
     * @param color 颜色值
     */
    public void borderColorPressed(int color) {
        borderColorPressed(color, true);
    }

    /**
     * 置按下边框颜色
     *
     * @param color   颜色值
     * @param refresh 是否立即刷新，默认为true
     */
    public void borderColorPressed(int color, boolean refresh) {
        mBorderColorPressed = color;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的边框颜色
     */
    public int borderColorPressed() {
        return mBorderColorPressed;
    }

    /**
     * 置按下边框类型
     *
     * @param type 边框类型，实线: View.BORDER_TYPE_SOLID; 虚线: View.BORDER_TYPE_DASHED
     */
    public void borderTypePressed(int type) {
        borderTypePressed(type, true);
    }

    /**
     * 置按下边框类型
     *
     * @param type    边框类型，实线: View.BORDER_TYPE_SOLID; 虚线: View.BORDER_TYPE_DASHED
     * @param refresh 是否立即刷新，默认为true
     */
    public void borderTypePressed(int type, boolean refresh) {
        mBorderTypePressed = type;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的边框类型
     */
    public int borderTypePressed() {
        return mBorderTypePressed;
    }

    /**
     * 置按下的圆角大小
     *
     * @param size 圆角大小
     */
    public void cornerPressed(float size) {
        cornerPressed(size, true);
    }

    /**
     * 置按下的圆角大小
     *
     * @param size    圆角大小
     * @param refresh 是否立即刷新，默认为true
     */
    public void cornerPressed(float size, boolean refresh) {
        mCornerRadiiPressed = new float[]{size, size, size, size, size, size, size, size};
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下的圆角大小
     *
     * @param topLeft     左上角
     * @param topRight    右上角
     * @param bottomRight 右下角
     * @param bottomLeft  左下角
     */
    public void cornerPressed(float topLeft, float topRight, float bottomRight, float bottomLeft) {
        cornerPressed(topLeft, topRight, bottomRight, bottomLeft, true);
    }

    /**
     * 置按下的圆角大小
     *
     * @param topLeft     左上角
     * @param topRight    右上角
     * @param bottomRight 右下角
     * @param bottomLeft  左下角
     * @param refresh     是否立即刷新，默认为true
     */
    public void cornerPressed(float topLeft, float topRight, float bottomRight, float bottomLeft, boolean refresh) {
        mCornerRadiiPressed = new float[]{topLeft, topLeft, topRight, topRight,
                bottomRight, bottomRight, bottomLeft, bottomLeft};
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 置按下的圆角大小
     *
     * @param topLeftX     左上角X
     * @param topLeftY     左上角Y
     * @param topRightX    右上角X
     * @param topRightY    右上角Y
     * @param bottomRightX 右下角X
     * @param bottomRightY 右下角Y
     * @param bottomLeftX  左下角X
     * @param bottomLeftY  左下角Y
     */
    public void cornerPressed(float topLeftX, float topLeftY, float topRightX, float topRightY,
                              float bottomRightX, float bottomRightY, float bottomLeftX, float bottomLeftY) {
        cornerPressed(topLeftX, topLeftY, topRightX, topRightY,
                bottomRightX, bottomRightY, bottomLeftX, bottomLeftY, true);
    }

    /**
     * 置按下的圆角大小
     *
     * @param topLeftX     左上角X
     * @param topLeftY     左上角Y
     * @param topRightX    右上角X
     * @param topRightY    右上角Y
     * @param bottomRightX 右下角X
     * @param bottomRightY 右下角Y
     * @param bottomLeftX  左下角X
     * @param bottomLeftY  左下角Y
     * @param refresh      是否立即刷新，默认为true
     */
    public void cornerPressed(float topLeftX, float topLeftY, float topRightX, float topRightY,
                              float bottomRightX, float bottomRightY, float bottomLeftX, float bottomLeftY, boolean refresh) {
        mCornerRadiiPressed = new float[]{topLeftX, topLeftY, topRightX, topRightY,
                bottomRightX, bottomRightY, bottomLeftX, bottomLeftY};
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的圆角大小
     *
     * @return 小数型数组共8个元素，分别是左上右下四个圆角的水平和垂直方向的圆角半径大小。
     */
    public float[] cornerPressed() {
        return mCornerRadiiPressed;
    }

    /**
     * 置按下的阴影半径大小
     *
     * @param radius 半径大小
     */
    public void shadowRadiusPressed(float radius) {
        shadowRadiusPressed(radius, true);
    }

    /**
     * 置按下的阴影半径大小
     *
     * @param radius  半径大小
     * @param refresh 是否立即刷新，默认为true
     */
    public void shadowRadiusPressed(float radius, boolean refresh) {
        mShadowRadiusPressed = radius;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的阴影半径大小
     */
    public float shadowRadiusPressed() {
        return mShadowRadiusPressed;
    }

    /**
     * 置按下的阴影颜色
     *
     * @param color 颜色值
     */
    public void shadowColorPressed(int color) {
        shadowColorPressed(color, true);
    }

    /**
     * 置按下的阴影颜色
     *
     * @param color   颜色值
     * @param refresh 是否立即刷新，默认为true
     */
    public void shadowColorPressed(int color, boolean refresh) {
        mShadowColorPressed = color;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的阴影颜色
     */
    public int shadowColorPressed() {
        return mShadowColorPressed;
    }

    /**
     * 置按下的阴影水平方向的偏移量
     *
     * @param dx 水平偏移
     */
    public void shadowDxPressed(float dx) {
        shadowDxPressed(dx, true);
    }

    /**
     * 置按下的阴影水平方向的偏移量
     *
     * @param dx      水平偏移
     * @param refresh 是否立即刷新，默认为true
     */
    public void shadowDxPressed(float dx, boolean refresh) {
        mShadowDxPressed = dx;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的阴影水平方向的偏移量
     */
    public float shadowDxPressed() {
        return mShadowDxPressed;
    }

    /**
     * 置按下的阴影垂直方向的偏移量
     *
     * @param dy 垂直偏移
     */
    public void shadowDyPressed(float dy) {
        shadowDyPressed(dy, true);
    }

    /**
     * 置按下的阴影垂直方向的偏移量
     *
     * @param dy      垂直偏移
     * @param refresh 是否立即刷新，默认为true
     */
    public void shadowDyPressed(float dy, boolean refresh) {
        mShadowDyPressed = dy;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的阴影垂直方向的偏移量
     */
    public float shadowDyPressed() {
        return mShadowDyPressed;
    }

    /**
     * 置按下的超文本
     *
     * @param content 超文本内容
     */
    public void htmlPressed(String content) {
        htmlPressed(content, true);
    }

    /**
     * 置按下的超文本
     *
     * @param content 超文本内容
     * @param refresh 是否立即刷新，默认为true
     */
    public void htmlPressed(String content, boolean refresh) {
        mHtmlPressed = content;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的超文本内容
     */
    public String htmlPressed() {
        return mHtmlPressed;
    }

    /**
     * 置按下的文本内容
     *
     * @param content 超文本内容
     */
    public void textPressed(String content) {
        textPressed(content, true);
    }

    /**
     * 置按下的文本内容
     *
     * @param content 超文本内容
     * @param refresh 是否立即刷新，默认为true
     */
    public void textPressed(String content, boolean refresh) {
        mTextPressed = content;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的文本内容
     */
    public String textPressed() {
        return mTextPressed;
    }

    /**
     * 置按下时是否添加下划线
     *
     * @param enable 是否添加下划线
     */
    public void underLinePressed(boolean enable) {
        underLinePressed(enable, true);
    }

    /**
     * 置按下时是否添加下划线
     *
     * @param enable  是否添加下划线
     * @param refresh 是否立即刷新，默认为true
     */
    public void underLinePressed(boolean enable, boolean refresh) {
        mUnderLinePressed = enable;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下时是否添加下划线
     */
    public boolean underLinePressed() {
        return mUnderLinePressed;
    }

    /**
     * 置按下时是否添加删除线
     *
     * @param enable 是否添加删除线
     */
    public void deleteLinePressed(boolean enable) {
        deleteLinePressed(enable, true);
    }

    /**
     * 置按下时是否添加删除线
     *
     * @param enable  是否添加删除线
     * @param refresh 是否立即刷新，默认为true
     */
    public void deleteLinePressed(boolean enable, boolean refresh) {
        mDeleteLinePressed = enable;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下时是否添加删除线
     */
    public boolean deleteLinePressed() {
        return mDeleteLinePressed;
    }

    /**
     * 置按下的文本样式
     *
     * @param style 样式类型
     */
    public void textStylePressed(int style) {
        textStylePressed(style, true);
    }

    /**
     * 置按下的文本样式
     *
     * @param style   样式类型
     * @param refresh 是否立即刷新，默认为true
     */
    public void textStylePressed(int style, boolean refresh) {
        mTextStylePressed = style;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的文本样式
     */
    public int textStylePressed() {
        return mTextStylePressed;
    }

    /**
     * 置按下的文本大小
     *
     * @param size 字体大小
     */
    public void textSizePressed(int size) {
        textSizePressed(size, true);
    }

    /**
     * 置按下的文本大小
     *
     * @param size    字体大小
     * @param refresh 是否立即刷新，默认为true
     */
    public void textSizePressed(int size, boolean refresh) {
        mTextSizePressed = size;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的文本大小
     */
    public int textSizePressed() {
        return mTextSizePressed;
    }

    /**
     * 置按下的文本颜色
     *
     * @param color 颜色值
     */
    public void textColorPressed(int color) {
        textColorPressed(color, true);
    }

    /**
     * 置按下的文本颜色
     *
     * @param color   颜色值
     * @param refresh 是否立即刷新，默认为true
     */
    public void textColorPressed(int color, boolean refresh) {
        mTextColorPressed = color;
        if (refresh) drawBackgroundDrawable(mPressStatus);
    }

    /**
     * 取按下的文本颜色
     */
    public int textColorPressed() {
        return mTextColorPressed;
    }

    /**
     * 文本限制最大长度
     *
     * @param length 长度
     */
    public void maxLength(int length) {
        setFilters(new InputFilter[]{new InputFilter.LengthFilter(length)});
    }

    /**
     * 文本限制最大行数
     *
     * @param lines 行数
     */
    public void maxLines(int lines) {
        setMaxLines(lines);
    }

    /**
     * 取文本限制的最大行数
     */
    public int maxLines() {
        return getMaxLines();
    }

    /**
     * 文本限制最小行数
     *
     * @param lines 行数
     */
    public void minLines(int lines) {
        setMinLines(lines);
    }

    /**
     * 取文本限制的最小行数
     */
    public int minLines() {
        return getMinLines();
    }

    /**
     * 设置文本内容
     *
     * @param t 文本内容
     */
    public void text(String t) {
        mText = t;
        setText(t);
    }

    /**
     * 取文本内容
     */
    public String text() {
        return CharSequenceUtils.getText(getText());
    }

    /**
     * 设置文本的对齐方式，参考Gravity类的常量。
     *
     * @param gravity 对齐方式
     */
    public void textGravity(int gravity) {
        setGravity(gravity);
    }

    /**
     * 取文本的对齐方式
     *
     * @return 返回对齐方式值，参考Gravity类的常量。
     */
    public int textGravity() {
        return getGravity();
    }

    /**
     * 设置文本字体大小
     *
     * @param unit 单位，参考Unit类的常量
     * @param size 字体大小
     */
    public void textSize(int unit, int size) {
        setTextSize(unit, size);
        mTextSize = (int) getTextSize();
    }

    /**
     * 设置文本的字体大小，单位为sp
     *
     * @param size 字体大小
     */
    public void textSize(int size) {
        setTextSize(size);
        mTextSize = (int) getTextSize();
    }

    /**
     * 取文本的字体大小
     */
    public float textSize() {
        return getTextSize();
    }

    /**
     * 设置文本颜色
     *
     * @param color 颜色值
     */
    public void textColor(int color) {
        mTextColor = color;
        setTextColor(color);
    }

    /**
     * 取文本颜色
     *
     * @return 返回颜色值
     */
    public int textColor() {
        return getCurrentTextColor();
    }

    /**
     * 设置文本的字体风格
     *
     * @param textStyle 字体风格类型，参考TextStyle类的常量
     */
    public void setTextStyle(int textStyle) {
        mTextStyle = textStyle;
        setTypeface(Typeface.defaultFromStyle(textStyle));
    }

    /**
     * 取文本的字体风格
     */
    public int getTextStyle() {
        Typeface typeface = getTypeface();
        if (typeface == null) return TextStyle.NORMAL;
        return typeface.getStyle();
    }

    /**
     * 判断文本是否加粗
     *
     * @return true=加粗；false=未加粗
     */
    public boolean isBold() {
        Typeface typeface = getTypeface();
        if (typeface == null) return false;
        return typeface.isBold();
    }

    /**
     * 判断文本是否为斜体
     *
     * @return true=斜体；false=非斜体
     */
    public boolean isItalic() {
        Typeface typeface = getTypeface();
        if (typeface == null) return false;
        return typeface.isItalic();
    }

    /**
     * 文本添加下划线
     *
     * @param underline 是否添加下划线
     */
    public void textUnderline(boolean underline) {
        mUnderLine = underline;
        setTitleStyle();
    }

    /**
     * 判断文本是否添加了下划线
     */
    public boolean textUnderline() {
        return mUnderLine;
    }

    /**
     * 文本添加删除线
     *
     * @param deleteLine 是否添加删除线
     */
    public void textDeleteLine(boolean deleteLine) {
        mDeleteLine = deleteLine;
        setTitleStyle();
    }

    /**
     * 判断文本是否添加了删除线
     */
    public boolean textDeleteLine() {
        return mDeleteLine;
    }

    /**
     * 是否启用单行模式
     *
     * @param singleLine 是否启用
     */
    public void singleLine(boolean singleLine) {
        setSingleLine(singleLine);
    }

    /**
     * 设置文本宽度超出范围时的省略类型
     *
     * @param type 省略类型，参考常量：ELLIPSIZE_***
     */
    public void ellipsize(int type) {
        TextUtils.TruncateAt pos = TextUtils.TruncateAt.END;
        switch (type) {
            case Ellipsize.START:
                pos = TextUtils.TruncateAt.START;
                break;
            case Ellipsize.MIDDLE:
                pos = TextUtils.TruncateAt.MIDDLE;
                break;
        }
        setEllipsize(pos);
    }

    /**
     * 指定文本的行数
     *
     * @param lines 行数
     */
    public void lines(int lines) {
        setLines(lines);
    }

    /**
     * 设置行高
     *
     * @param h 行高
     */
    public void lineHeight(int h) {
        setLineHeight(h);
    }

    /**
     * 取行高
     */
    public int lineHeight() {
        return getLineHeight();
    }

    /**
     * 设置文本的自定义字体，注意需要先获得读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param fontFilePath 本地的ttf等格式的字体文件
     * @return 返回是否设置成功
     */
    public boolean setFont(String fontFilePath) {
        if (fontFilePath == null || fontFilePath.length() <= 0) return false;
        Typeface typeface = Typeface.createFromFile(fontFilePath);
        return typeface != null && getPaint().setTypeface(typeface) != null;
    }

    /**
     * 加载html超文本
     *
     * @param htmlStr html超文本内容
     */
    public void loadHtml(String htmlStr) {
        mHtml = htmlStr;
        Spanned html = getHtmlText(htmlStr);
        if (html == null) return;
        setText(html);
    }

    //加载HTML文本,实现丰富文本的显示。
    //1.加载普通的HTML标签文本,例如：
    //"我是<font color="#FF0000">猎码</font>"
    //2.显示本地图片,例如：
    //<img src="+符号.引号+"storage/emulated/0/xxx.jpg"+符号.引号+" />"
    //3.显示资源图片,例如：
    //<img src="+符号.引号+图片.xxx+符号.引号+" />"
    //注意：android6.0以上版本,读取本地图片资源需要授权,如果HTML文本中包含本地图片路径,
    // "检测权限"需要传入真,否则在android6.0以上版本的手机无法正常显示本地图片
    //检测权限默认为真
    //另外,当检测权限为真时,最好不要在"窗口创建完毕"事件下使用此方法。
    private Spanned getHtmlText(String htmlStr) {
        Spanned html;
        if (Build.VERSION.SDK_INT >= 24) {
            html = Html.fromHtml(htmlStr, Html.FROM_HTML_MODE_COMPACT, getImageGetter(), null);
        } else {
            html = Html.fromHtml(htmlStr, getImageGetter(), null);
        }
        return html;
    }

    private Html.ImageGetter getImageGetter() {
        return new Html.ImageGetter() {
            public Drawable getDrawable(String source) {
                Drawable drawable = null;
                try {
                    //读取路径图片
                    drawable = Drawable.createFromPath(source);
                    if (drawable != null) {
                        drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
                        return drawable;
                    }
                    //读取R资源图片
                    int rId = Integer.parseInt(source);
                    drawable = getResources().getDrawable(rId);
                    if (drawable != null)
                        drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
                    return drawable;
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        };
    }

    //endregion

    /**
     * 取宽度
     */
    public int width() {
        return viewImpl.width();
    }

    /**
     * 置宽度
     *
     * @param w 宽度
     */
    public void width(int w) {
        viewImpl.width(w);
    }

    /**
     * 取高度
     */
    public int height() {
        return viewImpl.height();
    }

    /**
     * 置高度
     *
     * @param h 高度
     */
    public void height(int h) {
        viewImpl.height(h);
    }

    /**
     * 设置宽度和高度
     *
     * @param w 宽度
     * @param h 高度
     */
    public void setWidthHeight(int w, int h) {
        viewImpl.setWidthHeight(w, h);
    }

    /**
     * 设置最小宽度
     *
     * @param w 宽度
     */
    public void minWidth(int w) {
        viewImpl.minWidth(w);
    }

    /**
     * 取最小宽度
     */
    public int minWidth() {
        return viewImpl.minWidth();
    }

    /**
     * 设置最小高度
     *
     * @param h 高度
     */
    public void minHeight(int h) {
        viewImpl.minHeight(h);
    }

    /**
     * 取最小高度
     */
    public int minHeight() {
        return viewImpl.minHeight();
    }

    /**
     * 设置描述内容(setContentDescription)
     *
     * @param des 描述
     */
    public void description(String des) {
        viewImpl.description(des);
    }

    /**
     * 取描述内容(ContentDescription)
     */
    public String description() {
        return viewImpl.description();
    }

    /**
     * 置标签数据
     *
     * @param t 数据
     */
    public void tag(Object t) {
        viewImpl.tag(t);
    }

    /**
     * 置标签数据
     *
     * @param key 键名
     * @param t   数据
     */
    public void tag(int key, Object t) {
        viewImpl.tag(key, t);
    }

    /**
     * 取标签数据
     */
    public Object tag() {
        return viewImpl.tag();
    }

    /**
     * 取标签数据
     *
     * @param key 键名
     */
    public Object tag(int key) {
        return viewImpl.tag(key);
    }

    /**
     * 设置透明度
     *
     * @param a 透明度，0-1
     */
    public void alpha(float a) {
        viewImpl.alpha(a);
    }

    /**
     * 取透明度
     *
     * @return 0-1
     */
    public float alpha() {
        return viewImpl.alpha();
    }

    /**
     * 置内边距
     *
     * @param left   左内边距
     * @param top    上内边距
     * @param right  右内边距
     * @param bottom 下内边距
     */
    public void padding(int left, int top, int right, int bottom) {
        viewImpl.padding(left, top, right, bottom);
    }

    /**
     * 置水平方向的内边距
     *
     * @param left  左内边距
     * @param right 上内边距
     */
    public void paddingX(int left, int right) {
        viewImpl.paddingX(left, right);
    }

    /**
     * 置垂直方向的内边距
     *
     * @param top    上内边距
     * @param bottom 下内边距
     */
    public void paddingY(int top, int bottom) {
        viewImpl.paddingY(top, bottom);
    }

    /**
     * 置左内边距
     *
     * @param val 值
     */
    public void paddingLeft(int val) {
        viewImpl.paddingLeft(val);
    }

    /**
     * 取左内边距
     */
    public int paddingLeft() {
        return viewImpl.paddingLeft();
    }

    /**
     * 置上内边距
     *
     * @param val 值
     */
    public void paddingTop(int val) {
        viewImpl.paddingTop(val);
    }

    /**
     * 取上内边距
     */
    public int paddingTop() {
        return viewImpl.paddingTop();
    }

    /**
     * 置右内边距
     *
     * @param val 值
     */
    public void paddingRight(int val) {
        viewImpl.paddingRight(val);
    }

    /**
     * 取右内边距
     */
    public int paddingRight() {
        return viewImpl.paddingRight();
    }

    /**
     * 置下内边距
     *
     * @param val 值
     */
    public void paddingBottom(int val) {
        viewImpl.paddingBottom(val);
    }

    /**
     * 取下内边距
     */
    public int paddingBottom() {
        return viewImpl.paddingBottom();
    }

    /**
     * 置外边距
     *
     * @param left   左外边距
     * @param top    上外边距
     * @param right  右外边距
     * @param bottom 下外边距
     */
    public void margin(int left, int top, int right, int bottom) {
        viewImpl.margin(left, top, right, bottom);
    }

    /**
     * 置水平方向的外边距
     *
     * @param left  左外边距
     * @param right 右外边距
     */
    public void marginX(int left, int right) {
        viewImpl.marginX(left, right);
    }

    /**
     * 置垂直方向的外边距
     *
     * @param top    上外边距
     * @param bottom 下外边距
     */
    public void marginY(int top, int bottom) {
        viewImpl.marginY(top, bottom);
    }

    /**
     * 置左外边距
     *
     * @param val 值
     */
    public void marginLeft(int val) {
        viewImpl.marginLeft(val);
    }

    /**
     * 取左外边距
     */
    public int marginLeft() {
        return viewImpl.marginLeft();
    }

    /**
     * 置上外边距
     *
     * @param val 值
     */
    public void marginTop(int val) {
        viewImpl.marginTop(val);
    }

    /**
     * 取上外边距
     */
    public int marginTop() {
        return viewImpl.marginTop();
    }

    /**
     * 置右外边距
     *
     * @param val 值
     */
    public void marginRight(int val) {
        viewImpl.marginRight(val);
    }

    /**
     * 取右外边距
     */
    public int marginRight() {
        return viewImpl.marginRight();
    }

    /**
     * 置下外边距
     *
     * @param val 值
     */
    public void marginBottom(int val) {
        viewImpl.marginBottom(val);
    }

    /**
     * 取下外边距
     */
    public int marginBottom() {
        return viewImpl.marginBottom();
    }

    /**
     * 置可视状态
     *
     * @param v 可视状态，GONE: 消失不占位；INVISIBLE: 隐藏; VISIBLE: 可视
     */
    public void visibility(int v) {
        viewImpl.visibility(v);
    }

    /**
     * 取可视状态
     *
     * @return GONE: 消失不占位；INVISIBLE: 隐藏; VISIBLE: 可视
     */
    public int visibility() {
        return viewImpl.visibility();
    }


    /**
     * 关闭硬件加速
     */
    public void closeHardwareAcceleration() {
        viewImpl.closeHardwareAcceleration();
    }

    /**
     * 从父布局中删除自己
     */
    public void removeSelf() {
        viewImpl.removeSelf();
    }

    /**
     * 显示到顶层
     */
    public void toTop() {
        viewImpl.toTop();
    }

    /**
     * 取上下文
     */
    public Context getViewContext() {
        return viewImpl.getViewContext();
    }

    /**
     * 取id
     */
    public int getViewId() {
        return viewImpl.getViewId();
    }

    /**
     * 置视图id，需要android api 17才能使用
     */
    public int setViewId() {
        return viewImpl.setViewId();
    }

    /**
     * 取类的名称
     */
    public String getClassSimpleName() {
        return viewImpl.getClassSimpleName();
    }

    /**
     * 取父布局对象
     */
    public ViewParent getViewParent() {
        return viewImpl.getParentView();
    }

    /**
     * 取父布局id
     */
    public int getViewParentId() {
        return viewImpl.getParentId();
    }

    /**
     * 置启用状态
     *
     * @param enabled 是否启用
     */
    public void setEnabled(boolean enabled) {
        viewImpl.setEnabled(enabled);
    }

    /**
     * 获取焦点
     */
    public void focus() {
        viewImpl.focus();
    }

    /**
     * 取消焦点
     */
    public void blur() {
        viewImpl.blur();
    }

    /**
     * 置可否单击，默认为 false，若为 false，将无法产生click事件，onTouch事件中也无法触发弹起事件: ACTION_UP
     * 调用 setOnClick 函数后，自动置为 true
     *
     * @param enable 可否
     */
    public void clickable(boolean enable) {
        viewImpl.clickable(enable);
    }

    /**
     * 置可否触发长按事件，默认为 false，若为false，无法触发longClick事件
     * 调用 setOnLongClick 函数后，自动置为 true
     *
     * @param enable 可否
     */
    public void longClickable(boolean enable) {
        viewImpl.longClickable(enable);
    }

    /**
     * 置可获取焦点，使得组件在非触屏设备上拥有获取焦点的能力。
     *
     * @param enable 是否获取
     */
    public void focusable(boolean enable) {
        viewImpl.focusable(enable);
    }

    /**
     * 置可获取触摸屏模式的焦点，使得组件在触屏模式下获取焦点的能力
     *
     * @param enable 是否获取
     */
    public void focusableInTouchMode(boolean enable) {
        viewImpl.focusableInTouchMode(enable);
    }

    /**
     * 设置背景颜色
     *
     * @param color 颜色
     */
    public void backgroundColor(int color) {
        viewImpl.backgroundColor(color);
    }

    /**
     * 取背景颜色
     */
    public int backgroundColor() {
        return viewImpl.backgroundColor();
    }

    /**
     * 设置线性渐变背景
     *
     * @param x0        起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0        起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1        终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1        终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param colors    颜色数组，不同位置的颜色值
     * @param positions 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode      平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundLinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions, int mode) {
        viewImpl.setBackgroundLinearGradient(x0, y0, x1, y1, colors, positions, mode);
    }

    /**
     * 设置线性渐变背景
     *
     * @param x0     起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0     起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1     终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1     终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param color1 开始的颜色值
     * @param color2 结束的颜色值
     * @param mode   平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundLinearGradient(float x0, float y0, float x1, float y1, int color1, int color2, int mode) {
        viewImpl.setBackgroundLinearGradient(x0, y0, x1, y1, color1, color2, mode);
    }

    /**
     * 设置环形渐变背景
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius  环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *                0到-1时，表示按短边的比例计算；
     *                -1到-2时，表示按长边的比例计算。大于等于0表示固定的像素值。
     *                默认值为-2，即半径为视图最短边的长度。
     * @param colors  颜色数组，不同位置的颜色值
     * @param stops   位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode    平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundRadialGradient(float centerX, float centerY, float radius, int[] colors, float[] stops, int mode) {
        viewImpl.setBackgroundRadialGradient(centerX, centerY, radius, colors, stops, mode);
    }

    /**
     * 设置环形渐变背景
     * @param centerX     中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY     中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius      环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *                    0到-1时，表示按短边的比例计算；
     *                    -1到-2时，表示按长边的比例计算。大于等于0表示固定的像素值。
     *                    默认值为-2，即半径为视图最短边的长度。
     * @param centerColor 中心点颜色
     * @param edgeColor   边缘颜色
     * @param mode        平铺方式，参考"TileMode"类的常量
     */
    public void setBackgroundRadialGradient(float centerX, float centerY, float radius, int centerColor, int edgeColor, int mode) {
        viewImpl.setBackgroundRadialGradient(centerX, centerY, radius, centerColor, edgeColor, mode);
    }

    /**
     * 同时设置视图的四个角的圆角大小
     *
     * @param radius 圆角大小
     */
    public void corner(int radius) {
        viewImpl.corner(radius);
    }

    /**
     * 分别设置视图四个角的圆角大小
     *
     * @param topLeft     左上角
     * @param topRight    右上角
     * @param bottomRight 右下角
     * @param bottomLeft  左下角
     */
    public void corner(float topLeft, float topRight, float bottomRight, float bottomLeft) {
        viewImpl.corner(topLeft, topRight, bottomRight, bottomLeft);
    }

    /**
     * 视图有四个角，每个角有x和y两个方向的圆角大小，共8个圆角值
     *
     * @param topLeftX     左上角x方向的圆角大小
     * @param topLeftY     左上角y方向的圆角大小
     * @param topRightX    右上角x方向的圆角大小
     * @param topRightY    右上角y方向的圆角大小
     * @param bottomRightX 右下角x方向的圆角大小
     * @param bottomRightY 右下角y方向的圆角大小
     * @param bottomLeftX  左下角x方向的圆角大小
     * @param bottomLeftY  左下角y方向的圆角大小
     */
    public void corner(float topLeftX, float topLeftY, float topRightX, float topRightY,
                       float bottomRightX, float bottomRightY, float bottomLeftX, float bottomLeftY) {
        viewImpl.corner(topLeftX, topLeftY, topRightX, topRightY, bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
    }

    /**
     * 设置视图圆角化，其内部的子视图不会遮盖圆角
     * @param radius 圆角大小，单位为px
     */
    public void cornerClip(float radius) {
        viewImpl.setCornerClip(radius);
    }

    /**
     * 取消视图的圆角化
     */
    public void cancelCornerClip() {
        viewImpl.cancelCornerClip();
    }

    /**
     * 置边框宽度
     *
     * @param w 宽度
     */
    public void borderWidth(int w) {
        viewImpl.borderWidth(w);
    }

    /**
     * 取边框宽度
     */
    public int borderWidth() {
        return viewImpl.borderWidth();
    }

    /**
     * 置边框颜色
     *
     * @param color 颜色
     */
    public void borderColor(int color) {
        viewImpl.borderColor(color);
    }

    /**
     * 取边框颜色
     */
    public int borderColor() {
        return viewImpl.borderColor();
    }

    /**
     * 取背景图片的位图数据
     */
    public Bitmap getBackgroundBitmap() {
        return viewImpl.getBackgroundBitmap();
    }

    /**
     * 置背景图片
     *
     * @param resId 图片资源id
     */
    public void background(int resId) {
        viewImpl.background(resId);
    }

    /**
     * 置背景图片
     *
     * @param bitmap 图片位图数据
     */
    public void background(Bitmap bitmap) {
        viewImpl.background(bitmap);
    }

    /**
     * 置背景图片，注意需要先申请读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param filePath 图片文件地址
     */
    public void background(String filePath) {
        viewImpl.background(filePath);
    }

    /**
     * 置背景图片
     *
     * @param bytes 字节数组
     */
    public void background(byte[] bytes) {
        viewImpl.background(bytes);
    }

    /**
     * 置水波纹特效，注意设置该特效后，组件的其他圆角、阴影，边框等效果均失效。
     *
     * @param enable 是否启用
     */
    public void setRippleEffectEnable(boolean enable) {
        viewImpl.setRippleEffectEnable(enable);
    }

    /**
     * 置视图可视状态改变的事件回调
     *
     * @param event 回调的接口事件
     */
    public void setOnVisibilityChange(LonView.VisibilityChangeCallback event) {
        viewImpl.setOnVisibilityChange(event);
    }

    /**
     * 置视图焦点改变的事件回调
     *
     * @param event 回调的接口事件
     */
    public void setOnFocusChange(LonView.FocusChangeCallback event) {
        viewImpl.setOnFocusChange(event);
    }

    /**
     * 置视图尺寸被改变的事件回调
     *
     * @param event 回调的接口事件
     */
    public void setOnSizeChange(LonView.SizeChangeCallback event) {
        viewImpl.setOnSizeChange(event);
    }

    /**
     * 置视图生命周期改变的事件回调
     *
     * @param event 回调的接口事件
     */
    public void setOnLiftChange(LonView.LifeCallback event) {
        viewImpl.setOnLiftChange(event);
    }

    private LonView.TouchCallback mTouchCallback;
    private LonView.ClickCallback mClickCallback;
    private LonView.ClickCallback mLongClickCallback;

    private void callButtonOnClick() {
        viewImpl.setOnClick(new LonView.ClickCallback() {
            @Override
            public void onClick(android.view.View view) {
                super.onClick(view);
                if (mClickCallback != null) mClickCallback.onClick(view);
            }
        });
    }

    private void callButtonOnLongClick() {
        viewImpl.setOnLongClick(new LonView.ClickCallback() {
            @Override
            public boolean onLongClick(android.view.View view) {
                super.onLongClick(view);
                if (mLongClickCallback != null) return mLongClickCallback.onLongClick(view);
                return false;
            }
        });
    }

    private void callButtonOnTouch() {
        viewImpl.setOnTouch(new LonView.TouchCallback() {
            @Override
            public void onTouchDown(android.view.View view, LonView.TouchMotion touchMotion) {
                super.onTouchDown(view, touchMotion);
                if (!mPressStatus) {
                    mPressStatus = true;
                    drawBackgroundDrawable(true);
                }
                if (mTouchCallback != null) mTouchCallback.onTouchDown(view, touchMotion);
            }

            @Override
            public void onTouchUp(android.view.View view, LonView.TouchMotion touchMotion) {
                super.onTouchUp(view, touchMotion);
                if (mPressStatus) {
                    mPressStatus = false;
                    drawBackgroundDrawable(false);
                }
                if (mTouchCallback != null) mTouchCallback.onTouchUp(view, touchMotion);
            }

            @Override
            public void onTouchCancel(android.view.View view, LonView.TouchMotion touchMotion) {
                super.onTouchCancel(view, touchMotion);
                if (mPressStatus) {
                    mPressStatus = false;
                    drawBackgroundDrawable(false);
                }
                if (mTouchCallback != null) mTouchCallback.onTouchCancel(view, touchMotion);
            }

            @Override
            public void onSlide(android.view.View view, LonView.TouchMotion touchMotion, float startX, float startY, float currentX, float currentY) {
                super.onSlide(view, touchMotion, startX, startY, currentX, currentY);
                if (mTouchCallback != null)
                    mTouchCallback.onSlide(view, touchMotion, startX, startY, currentX, currentY);
            }

            @Override
            public void onMultiTouch(android.view.View view, LonView.TouchMotion touchMotion) {
                super.onMultiTouch(view, touchMotion);
                if (mTouchCallback != null) mTouchCallback.onMultiTouch(view, touchMotion);
            }

            @Override
            public boolean intercept(android.view.View view, LonView.TouchMotion touchMotion) {
                super.intercept(view, touchMotion);
                if (mTouchCallback != null) return mTouchCallback.intercept(view, touchMotion);
                return false;
            }
        });
    }

    /**
     * 置被单击的回调事件
     *
     * @param event 回调的接口事件
     */
    public void setOnClick(LonView.ClickCallback event) {
        mClickCallback = event;
    }

    /**
     * 置被长按的回调
     *
     * @param event 回调的接口事件
     */
    public void setOnLongClick(LonView.ClickCallback event) {
        mLongClickCallback = event;
    }

    /**
     * 置触摸回调
     *
     * @param touchCallback 回调事件
     */
    public void setOnTouch(LonView.TouchCallback touchCallback) {
        mTouchCallback = touchCallback;
    }

    @Override
    public void onViewVisibilityChanged(android.view.View view, int visibility) {

    }

    @Override
    public void onViewCreate() {

    }

    @Override
    public void onViewDestroy() {

    }

    @Override
    public void onViewFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {

    }

    @Override
    public void onViewSizeChange(int newWidth, int newHeight, int oldWidth, int oldHeight) {

    }

    @Override
    protected void onVisibilityChanged(@NonNull android.view.View v, int visibility) {
        super.onVisibilityChanged(v, visibility);
        viewImpl.callVisibilityChangeCallback(v, visibility);
        onViewVisibilityChanged(v, visibility);
    }

    @Override
    protected void onFocusChanged(boolean gainFocus, int direction, @Nullable Rect previouslyFocusedRect) {
        super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
        viewImpl.callFocusChangeCallback(gainFocus, direction, previouslyFocusedRect);
        onViewFocusChanged(gainFocus, direction, previouslyFocusedRect);
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        viewImpl.callViewDestroy();
        onViewDestroy();
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        viewImpl.callViewDestroy();
        onViewCreate();
    }

    @Override
    protected void onSizeChanged(int newWidth, int newHeight, int oldWidth, int oldHeight) {
        super.onSizeChanged(newWidth, newHeight, oldWidth, oldHeight);
        viewImpl.callSizeChangeCallback(newWidth, newHeight, oldWidth, oldHeight);
        onViewSizeChange(newWidth, newHeight, oldWidth, oldHeight);
    }
}
